home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / emulator / uae-0.000 / uae-0 / uae-0.6.0 / gencpu.c < prev    next >
C/C++ Source or Header  |  1996-05-26  |  65KB  |  1,903 lines
  1. /* 
  2.  * UAE - The Un*x Amiga Emulator
  3.  *
  4.  * MC68000 emulation generator
  5.  *
  6.  * This is a fairly stupid program that generates a lot of case labels that 
  7.  * can be #included in a switch statement.
  8.  * As an alternative, it can generate functions that handle specific
  9.  * MC68000 instructions, plus a prototype header file and a function pointer
  10.  * array to look up the function for an opcode.
  11.  * Error checking is bad, an illegal table68k file will cause the program to
  12.  * call abort().
  13.  * The generated code is sometimes sub-optimal, an optimizing compiler should 
  14.  * take care of this.
  15.  * 
  16.  * (c) 1995 Bernd Schmidt
  17.  * 
  18.  */
  19.  
  20. #include "sysconfig.h"
  21. #include "sysdeps.h"
  22. #include <ctype.h>
  23.  
  24. #include "config.h"
  25. #include "options.h"
  26. #include "readcpu.h"
  27.  
  28. #define BOOL_TYPE "int"
  29.  
  30. long int counts[65536];
  31.  
  32. static int isspecific(int opcode)
  33. {
  34.     return counts[opcode]>5;
  35. }
  36.  
  37. static void read_counts(void)
  38. {
  39.     FILE *file;
  40.     unsigned long opcode,count, total;
  41.     int trapcount=0;
  42.     int trap=0;
  43.     memset(counts, 0, sizeof counts);
  44.  
  45.     file=fopen("insncount","r");
  46.     if(file)
  47.     {
  48.     fscanf(file,"Total: %d",&total);
  49.     while(fscanf(file,"%x: %d\n",&opcode,&count)==2)
  50.     {
  51.         counts[opcode]=10000.0*count/total;
  52.         if(isspecific(opcode))
  53.         {
  54.         trapcount+=count;
  55.         trap++;
  56.         }
  57.     }
  58. #if 0
  59.     fprintf(stderr,"trap %d function: %f%\n",trap,100.0*trapcount/total);
  60. #endif
  61.     }
  62. }
  63.  
  64.  
  65. static int n_braces = 0;
  66.  
  67. static void start_brace(void)
  68. {
  69.     n_braces++;
  70.     printf("{");
  71. }
  72.  
  73. static void close_brace(void)
  74. {
  75.     assert (n_braces > 0);
  76.     n_braces--;
  77.     printf("}");
  78. }
  79.  
  80. static void finish_braces(void)
  81. {
  82.     while (n_braces > 0)
  83.     close_brace();
  84. }
  85.  
  86. static void pop_braces(int to)
  87. {
  88.     while (n_braces > to)
  89.     close_brace();
  90. }
  91.  
  92. static void genamode(amodes mode, char *reg, wordsizes size, char *name, int getv, int movem)
  93. {
  94.     start_brace ();
  95.     switch(mode) {
  96.      case Dreg:
  97.     if (movem)
  98.         abort();
  99.     if (getv)
  100.         switch(size) {      
  101.          case sz_byte:
  102.         printf("\tBYTE %s = regs.d[%s];\n", name, reg);
  103.         break;
  104.          case sz_word:
  105.         printf("\tWORD %s = regs.d[%s];\n", name, reg);
  106.         break;
  107.          case sz_long:
  108.         printf("\tLONG %s = regs.d[%s];\n", name, reg);
  109.         break;
  110.          default: abort();
  111.         }
  112.     break;
  113.      case Areg:
  114.     if (movem)
  115.         abort();
  116.     if (getv)
  117.         switch(size) {      
  118.          case sz_word:
  119.         printf("\tWORD %s = regs.a[%s];\n", name, reg);
  120.         break;
  121.          case sz_long:
  122.         printf("\tLONG %s = regs.a[%s];\n", name, reg);
  123.         break;
  124.          default: abort();
  125.         }
  126.     break;
  127.      case Aind:
  128.     printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
  129.     if (getv)
  130.         switch(size) {      
  131.          case sz_byte:
  132.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  133.         break;
  134.          case sz_word:
  135.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  136.         break;
  137.          case sz_long:
  138.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  139.         break;
  140.          default: abort();
  141.         }
  142.     break;
  143.      case Aipi:
  144.     printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
  145.     switch(size) {
  146.      case sz_byte:        
  147.         if (getv) printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  148.         if (!movem) {
  149.         start_brace();
  150.         printf("\tregs.a[%s] += areg_byteinc[%s];\n", reg, reg);
  151.         }
  152.         break;
  153.      case sz_word:
  154.         if (getv) printf("\tWORD %s = get_word(%sa);\n", name, name);
  155.         if (!movem) {
  156.         start_brace();
  157.         printf("\tregs.a[%s] += 2;\n", reg);
  158.         }
  159.         break;
  160.      case sz_long:
  161.         if (getv) printf("\tLONG %s = get_long(%sa);\n", name, name);
  162.         if (!movem) {
  163.         start_brace();
  164.         printf("\tregs.a[%s] += 4;\n", reg);
  165.         }
  166.         break;
  167.      default: abort();
  168.     }
  169.     break;
  170.      case Apdi:
  171.     switch(size) {      
  172.      case sz_byte:
  173.         if (!movem) printf("\tregs.a[%s] -= areg_byteinc[%s];\n", reg, reg);
  174.         start_brace();
  175.         printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
  176.         if (getv) printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  177.         break;
  178.      case sz_word:
  179.         if (!movem) printf("\tregs.a[%s] -= 2;\n", reg);
  180.         start_brace();
  181.         printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
  182.         if (getv) printf("\tWORD %s = get_word(%sa);\n", name, name);
  183.         break;
  184.      case sz_long:
  185.         if (!movem) printf("\tregs.a[%s] -= 4;\n", reg);
  186.         start_brace();
  187.         printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
  188.         if (getv) printf("\tLONG %s = get_long(%sa);\n", name, name);
  189.         break;
  190.      default: abort();
  191.     }
  192.     break;
  193.      case Ad16:
  194.     printf("\tCPTR %sa = regs.a[%s] + (LONG)(WORD)nextiword();\n", name, reg);
  195.     if (getv) 
  196.         switch(size) {      
  197.          case sz_byte:
  198.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  199.         break;
  200.          case sz_word:
  201.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  202.         break;
  203.          case sz_long:
  204.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  205.         break;
  206.          default: abort();
  207.         }
  208.     break;
  209.      case Ad8r:
  210.     printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
  211. #if 0
  212.     printf("\tUWORD %sdp = nextiword();\n", name);
  213.     printf("\t%sa += (LONG)(BYTE)(%sdp & 0xFF);\n", name, name);
  214.     start_brace();
  215.     printf("\tULONG %sdpr = %sdp & 0x8000 ? regs.a[(%sdp & 0x7000) >> 12] : regs.d[(%sdp & 0x7000) >> 12];\n", name, name, name, name);
  216.     printf("\tif (!(%sdp & 0x800)) %sdpr = (LONG)(WORD)%sdpr;\n", name, name, name);
  217.     printf("\t%sa += %sdpr;\n", name, name);
  218. #endif
  219.     printf("\t%sa = get_disp_ea (%sa, nextiword());\n", name, name);
  220.     if (getv) {
  221.         start_brace();
  222.         switch(size) {      
  223.          case sz_byte:
  224.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  225.         break;
  226.          case sz_word:
  227.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  228.         break;
  229.          case sz_long:
  230.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  231.         break;
  232.          default: abort();
  233.         }
  234.     }
  235.     break;
  236.      case PC16:
  237.     printf("\tCPTR %sa = m68k_getpc();\n", name);
  238.     printf("\t%sa += (LONG)(WORD)nextiword();\n", name);
  239.     if (getv) {
  240.         start_brace();
  241.         switch(size) {      
  242.          case sz_byte:
  243.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  244.         break;
  245.          case sz_word:
  246.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  247.         break;
  248.          case sz_long:
  249.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  250.         break;
  251.          default: abort();
  252.         }
  253.     }
  254.     break;
  255.      case PC8r:
  256.     printf("\tCPTR %sa = m68k_getpc();\n", name);
  257. #if 0
  258.     printf("\tUWORD %sdp = nextiword();\n", name);
  259.     printf("\t%sa += (LONG)(BYTE)(%sdp & 0xFF);\n", name, name);
  260.     start_brace();
  261.     printf("\tULONG %sdpr = %sdp & 0x8000 ? regs.a[(%sdp & 0x7000) >> 12] : regs.d[(%sdp & 0x7000) >> 12];\n", name, name, name, name);
  262.     printf("\tif (!(%sdp & 0x800)) %sdpr = (LONG)(WORD)%sdpr;\n", name, name, name);
  263.     printf("\t%sa += %sdpr;\n", name, name);
  264. #endif
  265.     printf("\t%sa = get_disp_ea (%sa, nextiword());\n", name, name);
  266.     if (getv) {
  267.         start_brace();
  268.         switch(size) {      
  269.          case sz_byte:
  270.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  271.         break;
  272.          case sz_word:
  273.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  274.         break;
  275.          case sz_long:
  276.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  277.         break;
  278.          default: abort();
  279.         }
  280.     }
  281.     break;
  282.      case absw:
  283.     printf("\tCPTR %sa = (LONG)(WORD)nextiword();\n", name);
  284.     if (getv) 
  285.         switch(size) {      
  286.          case sz_byte:
  287.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  288.         break;
  289.          case sz_word:
  290.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  291.         break;
  292.          case sz_long:
  293.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  294.         break;
  295.          default: abort();
  296.         }
  297.     break;
  298.      case absl:
  299.     printf("\tCPTR %sa = nextilong();\n", name);
  300.     if (getv) 
  301.         switch(size) {      
  302.          case sz_byte:
  303.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  304.         break;
  305.          case sz_word:
  306.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  307.         break;
  308.          case sz_long:
  309.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  310.         break;
  311.          default: abort();
  312.         }
  313.     break;
  314.      case imm:
  315.     if (getv) 
  316.         switch(size) {
  317.          case sz_byte:
  318.         printf("\tBYTE %s = nextiword();\n", name);
  319.         break;
  320.          case sz_word:
  321.         printf("\tWORD %s = nextiword();\n", name);
  322.         break;
  323.          case sz_long:
  324.         printf("\tLONG %s = nextilong();\n", name);
  325.         break;
  326.          default: abort();
  327.         }
  328.     break;
  329.      case imm0:
  330.     if (!getv) abort();
  331.     printf("\tBYTE %s = nextiword();\n", name);
  332.     break;
  333.      case imm1:
  334.     if (!getv) abort();
  335.     printf("\tWORD %s = nextiword();\n", name);
  336.     break;
  337.      case imm2:
  338.     if (!getv) abort();
  339.         printf("\tLONG %s = nextilong();\n", name);
  340.     break;
  341.      case immi:
  342.     if (!getv) abort();
  343.     printf("\tULONG %s = %s;\n", name, reg);
  344.     break;
  345.      default: 
  346.     abort();
  347.     }
  348. }
  349.  
  350. static void genastore(char *from, amodes mode, char *reg, wordsizes size, char *to)
  351. {
  352.     switch(mode) {
  353.      case Dreg:
  354.     switch(size) {      
  355.      case sz_byte:
  356.         printf("\tregs.d[%s] &= ~0xff; regs.d[%s] |= (%s) & 0xff;\n", reg, reg, from);
  357.         break;
  358.      case sz_word:
  359.         printf("\tregs.d[%s] &= ~0xffff; regs.d[%s] |= (%s) & 0xffff;\n", reg, reg, from);
  360.         break;
  361.      case sz_long:
  362.         printf("\tregs.d[%s] = (%s);\n", reg, from);
  363.         break;
  364.      default: abort();
  365.     }
  366.     break;
  367.      case Areg:
  368.     switch(size) {      
  369.      case sz_word:
  370.         printf("\tregs.a[%s] = (LONG)(WORD)(%s);\n", reg, from);
  371.         break;
  372.      case sz_long:
  373.         printf("\tregs.a[%s] = (%s);\n", reg, from);
  374.         break;
  375.      default: abort();
  376.     }
  377.     break;
  378.      case Aind:
  379.      case Aipi:
  380.      case Apdi:
  381.      case Ad16:
  382.      case Ad8r:
  383.      case absw:
  384.      case absl:
  385.     switch(size) {
  386.      case sz_byte:
  387.         printf("\tput_byte(%sa,%s);\n", to, from);
  388.         break;
  389.      case sz_word:
  390.         printf("\tput_word(%sa,%s);\n", to, from);
  391.         break;
  392.      case sz_long:
  393.         printf("\tput_long(%sa,%s);\n", to, from);
  394.         break;
  395.      default: abort();
  396.     }
  397.     break;
  398.      case PC16:
  399.      case PC8r:
  400.     switch(size) {
  401.      case sz_byte:
  402.         printf("\tput_byte(%sa,%s);\n", to, from);
  403.         break;
  404.      case sz_word:
  405.         if (CPU_LEVEL < 2)
  406.         abort();
  407.         printf("\tput_word(%sa,%s);\n", to, from);
  408.         break;
  409.      case sz_long:
  410.         if (CPU_LEVEL < 2)
  411.         abort();
  412.         printf("\tput_long(%sa,%s);\n", to, from);
  413.         break;
  414.      default: abort();
  415.     }
  416.     break;
  417.      case imm:
  418.      case imm0:
  419.      case imm1:
  420.      case imm2:
  421.      case immi:
  422.     abort();
  423.     break;
  424.      default: 
  425.     abort();
  426.     }
  427. }
  428.  
  429. static void genmovemel(UWORD opcode)
  430. {
  431.     char getcode[100];
  432.     int size = table68k[opcode].size == sz_long ? 4 : 2;
  433.     
  434.     if (table68k[opcode].size == sz_long) {    
  435.         strcpy(getcode, "get_long(srca)");
  436.     } else {        
  437.         strcpy(getcode, "(LONG)(WORD)get_word(srca)");
  438.     }
  439.     
  440.     printf("\tUWORD mask = nextiword(), bitmask = mask;\n");
  441.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 1);
  442.     start_brace();
  443.     printf("\tint i, bitcnt = 0;\n");
  444.     printf("\tfor(i=0;i<16;i++) { bitcnt += bitmask & 1; bitmask >>= 1; }\n");
  445.     
  446.     printf("\tfor(i=0;i<8;i++) { if (mask & 1) { regs.d[i] = %s; srca += %d; } mask >>= 1; }\n", getcode, size);
  447.     printf("\tfor(i=0;i<8;i++) { if (mask & 1) { regs.a[i] = %s; srca += %d; } mask >>= 1; }\n", getcode, size);
  448.     
  449.     if (table68k[opcode].smode == Aipi)
  450.         printf("\tregs.a[srcreg] = srca;\n");
  451. }
  452.  
  453. static void genmovemle(UWORD opcode)
  454. {
  455.     char putcode[100], shiftcode[] = ">>";
  456.     int size = table68k[opcode].size == sz_long ? 4 : 2;
  457.     int mask = 1;
  458.     if (table68k[opcode].size == sz_long) {
  459.         strcpy(putcode, "put_long(srca,");
  460.     } else {        
  461.         strcpy(putcode, "put_word(srca,");
  462.     }
  463.     
  464.     printf("\tUWORD mask = nextiword(), bitmask = mask;\n");
  465.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 1);
  466.     start_brace();
  467.     printf("\tint i, bitcnt = 0;\n");
  468.     printf("\tULONG rd[8], ra[8];\n");
  469.     printf("\tfor(i=0;i<16;i++) { bitcnt += bitmask & 1; bitmask >>= 1; }\n");
  470.     printf("\tfor(i=0;i<8;i++) { rd[i] = regs.d[i]; ra[i] = regs.a[i]; }\n");
  471.     if (table68k[opcode].smode == Apdi) {
  472.     printf("\tsrca -= %d*bitcnt;\n", size);
  473.     printf("\tregs.a[srcreg] = srca;\n");
  474.     strcpy(shiftcode, "<<");
  475.     mask = 0x8000;
  476.     }
  477.  
  478.     printf("\tfor(i=0;i<8;i++) { if (mask & %d) { %s rd[i]); srca += %d; } mask %s= 1; }\n", 
  479.        mask, putcode, size, shiftcode);
  480.     printf("\tfor(i=0;i<8;i++) { if (mask & %d) { %s ra[i]); srca += %d; } mask %s= 1; }\n",
  481.        mask, putcode, size, shiftcode);    
  482. }
  483.  
  484. typedef enum {
  485.     flag_logical, flag_add, flag_sub, flag_cmp, flag_addx, flag_subx, flag_zn,
  486.     flag_av, flag_sv
  487. } flagtypes;
  488.  
  489. static void genflags_normal(flagtypes type, wordsizes size, char *value, char *src, char *dst)
  490. {
  491.     char vstr[100],sstr[100],dstr[100];
  492.     char usstr[100],udstr[100];
  493.     char unsstr[100],undstr[100];
  494.  
  495.     switch(size) {        
  496.      case sz_byte:
  497.     strcpy(vstr, "((BYTE)(");
  498.     strcpy(usstr, "((UBYTE)(");
  499.     break;
  500.      case sz_word:
  501.     strcpy(vstr, "((WORD)(");
  502.     strcpy(usstr, "((UWORD)(");
  503.     break;
  504.      case sz_long:
  505.     strcpy(vstr, "((LONG)(");
  506.     strcpy(usstr, "((ULONG)(");
  507.     break;
  508.      default:
  509.     abort();
  510.     }
  511.     strcpy(unsstr, usstr); 
  512.  
  513.     strcpy(sstr, vstr);
  514.     strcpy(dstr, vstr);
  515.     strcat(vstr, value); strcat(vstr,"))");
  516.     strcat(dstr, dst); strcat(dstr,"))");
  517.     strcat(sstr, src); strcat(sstr,"))");
  518.     
  519.     strcpy(udstr, usstr);
  520.     strcat(udstr, dst); strcat(udstr,"))");
  521.     strcat(usstr, src); strcat(usstr,"))");
  522.     
  523.     strcpy(undstr, unsstr);
  524.     strcat(unsstr, "-");
  525.     strcat(undstr, "~");
  526.     strcat(undstr, dst); strcat(undstr,"))");
  527.     strcat(unsstr, src); strcat(unsstr,"))");
  528.  
  529.     switch (type) {
  530.      case flag_logical:
  531.      case flag_zn:
  532.      case flag_av:
  533.      case flag_sv:
  534.      case flag_addx:
  535.      case flag_subx:
  536.     break;
  537.     
  538.      case flag_add:
  539.     start_brace();
  540.     printf("ULONG %s = %s + %s;\n", value, dstr, sstr);
  541.     break;
  542.      case flag_sub:
  543.      case flag_cmp:
  544.     start_brace();
  545.     printf("ULONG %s = %s - %s;\n", value, dstr, sstr);
  546.     break;
  547.     }
  548.  
  549.  
  550.     switch (type) {
  551.      case flag_logical:
  552.      case flag_zn:
  553.     break;
  554.     
  555.      case flag_add:
  556.      case flag_sub:
  557.      case flag_addx:
  558.      case flag_subx:
  559.      case flag_cmp:
  560.      case flag_av:
  561.      case flag_sv:
  562.     start_brace();
  563.     printf("\t"BOOL_TYPE" flgs = %s < 0;\n", sstr);
  564.     printf("\t"BOOL_TYPE" flgo = %s < 0;\n", dstr);
  565.     printf("\t"BOOL_TYPE" flgn = %s < 0;\n", vstr);
  566.     break;
  567.     }
  568.     
  569.     switch(type) {
  570.      case flag_logical:
  571.     printf("\tVFLG = CFLG = 0;\n");
  572.     printf("\tZFLG = %s == 0;\n", vstr);
  573.     printf("\tNFLG = %s < 0;\n", vstr);
  574.     break;
  575.      case flag_av:
  576.     printf("\tVFLG = (flgs == flgo) && (flgn != flgo);\n");
  577.     break;
  578.      case flag_sv:
  579.     printf("\tVFLG = (flgs != flgo) && (flgn != flgo);\n");
  580.     break;
  581.      case flag_zn:
  582.     printf("\tif (%s != 0) ZFLG = 0;\n", vstr);
  583.     printf("\tNFLG = %s < 0;\n", vstr);
  584.     break;
  585.      case flag_add:
  586.     printf("\tZFLG = %s == 0;\n", vstr);
  587.     printf("\tVFLG = (flgs == flgo) && (flgn != flgo);\n");
  588.     printf("\tCFLG = regs.x = %s < %s;\n", undstr, usstr);
  589.     printf("\tNFLG = flgn != 0;\n");
  590.     break;
  591.      case flag_sub:
  592.     printf("\tZFLG = %s == 0;\n", vstr);
  593.     printf("\tVFLG = (flgs != flgo) && (flgn != flgo);\n");
  594.     printf("\tCFLG = regs.x = %s > %s;\n", usstr, udstr);
  595.     printf("\tNFLG = flgn != 0;\n");
  596.     break;
  597.      case flag_addx:
  598.     printf("\tVFLG = (flgs && flgo && !flgn) || (!flgs && !flgo && flgn);\n");
  599.     printf("\tregs.x = CFLG = (flgs && flgo) || (!flgn && (flgo || flgs));\n");
  600.     break;
  601.      case flag_subx:
  602.     printf("\tVFLG = (!flgs && flgo && !flgn) || (flgs && !flgo && flgn);\n");
  603.     printf("\tregs.x = CFLG = (flgs && !flgo) || (flgn && (!flgo || flgs));\n");
  604.     break;
  605.      case flag_cmp:
  606.     printf("\tZFLG = %s == 0;\n", vstr);
  607.     printf("\tVFLG = (flgs != flgo) && (flgn != flgo);\n");
  608.     printf("\tCFLG = %s > %s;\n", usstr, udstr);
  609.     printf("\tNFLG = flgn != 0;\n");
  610.     break;
  611.     }
  612. }
  613.  
  614. static void genflags(flagtypes type, wordsizes size, char *value, char *src, char *dst)
  615. {
  616. #ifdef INTEL_FLAG_OPT
  617.     
  618.     switch (type) {
  619.      case flag_logical:
  620.      case flag_av:
  621.      case flag_sv:
  622.      case flag_zn:
  623.      case flag_addx:
  624.      case flag_subx:
  625.     break;
  626.  
  627.      case flag_add:
  628.      case flag_sub:
  629.      case flag_cmp:
  630.     start_brace();
  631.     printf("\tULONG %s;\n", value);
  632.     break;
  633.     }
  634.  
  635.     switch(type) {
  636.      case flag_av:
  637.      case flag_sv:
  638.      case flag_zn:
  639.      case flag_addx:
  640.      case flag_subx:
  641.     break;
  642.  
  643.      case flag_logical:
  644.     if (strcmp(value, "0") == 0) {
  645.         /* GCC doesn't want to load the constant into a register. 
  646.          * intel_flag_lookup[64] is just the zero flag set. */
  647.         printf("\tregflags = intel_flag_lookup[64];\n");
  648.     } else {
  649.         switch(size) {
  650.          case sz_byte:
  651.         printf("\t__asm__(\"testb %%0,%%0; lahf; movzbl %%%%ah,%%%%eax; movl intel_flag_lookup(,%%%%eax,4),%%%%eax; movl %%%%eax,regflags\""
  652.                ": : \"r\" (%s) : \"%%eax\", \"cc\");", value);
  653.         break;
  654.          case sz_word:
  655.         printf("\t__asm__(\"testw %%0,%%0; lahf; movzbl %%%%ah,%%%%eax; movl intel_flag_lookup(,%%%%eax,4),%%%%eax; movl %%%%eax,regflags\""
  656.                ": : \"r\" (%s) : \"%%eax\", \"cc\");", value);
  657.         break;
  658.          case sz_long:
  659.         printf("\t__asm__(\"testl %%0,%%0; lahf; movzbl %%%%ah,%%%%eax; movl intel_flag_lookup(,%%%%eax,4),%%%%eax; movl %%%%eax,regflags\""
  660.                ": : \"r\" (%s) : \"%%eax\", \"cc\");", value);
  661.         
  662.         break;
  663.          case sz_unknown:
  664.         abort();
  665.         }
  666.     }
  667.     return;
  668.  
  669.      case flag_add:
  670.     /* Of course it would be better to let GCC find a proper register to 
  671.      * compute newv in, but it does not seem to like reloading the 8 bit
  672.      * regs. */
  673.     switch (size) {
  674.      case sz_byte:
  675.         printf("\t__asm__(\"addb %%b3,%%b0; lahf; movzbl %%%%ah,%%%%eax;"
  676.            " movl intel_flag_lookup(,%%%%eax,4),%%%%eax; seto %%%%al; movb %%%%ah,%%1; movl %%%%eax,regflags \""
  677.            ": \"=&q\" (%s), \"=m\" (regs.x) "
  678.            ": \"0\" ((BYTE)(%s)), \"qm\" ((BYTE)(%s)) : \"cc\", \"%%eax\");",
  679.            value, src, dst);
  680.         break;
  681.      case sz_word:
  682.         printf("\t__asm__(\"addw %%w3,%%w0; lahf; movzbl %%%%ah,%%%%eax;"
  683.            " movl intel_flag_lookup(,%%%%eax,4),%%%%eax; seto %%%%al; movb %%%%ah,%%1; movl %%%%eax,regflags \""
  684.            ": \"=&r\" (%s), \"=m\" (regs.x) "
  685.            ": \"0\" ((WORD)(%s)), \"rmi\" ((WORD)(%s)) : \"cc\", \"%%eax\");",
  686.            value, src, dst);
  687.         break;
  688.      case sz_long:
  689.         printf("\t__asm__(\"addl %%3,%%0; lahf; movzbl %%%%ah,%%%%eax;"
  690.            " movl intel_flag_lookup(,%%%%eax,4),%%%%eax; seto %%%%al; movb %%%%ah,%%1; movl %%%%eax,regflags \""
  691.            ": \"=&r\" (%s), \"=m\" (regs.x) "
  692.            ": \"0\" ((LONG)(%s)), \"rmi\" ((LONG)(%s)) : \"cc\", \"%%eax\");",
  693.            value, src, dst);
  694.         break;
  695.      case sz_unknown:
  696.         abort();
  697.     }
  698.     return;
  699.  
  700.      case flag_sub:
  701.     switch (size) {
  702.      case sz_byte:
  703.         printf("\t__asm__(\"subb %%b2,%%b0; lahf; movzbl %%%%ah,%%%%eax;"
  704.            " movl intel_flag_lookup(,%%%%eax,4),%%%%eax; seto %%%%al; movb %%%%ah,%%1; movl %%%%eax,regflags \""
  705.            ": \"=&q\" (%s), \"=m\" (regs.x) "
  706.            ": \"qmi\" ((BYTE)(%s)), \"0\" ((BYTE)(%s)) : \"cc\", \"%%eax\");",
  707.            value, src, dst);
  708.         break;
  709.      case sz_word:
  710.         printf("\t__asm__(\"subw %%w2,%%w0; lahf; movzbl %%%%ah,%%%%eax;"
  711.            " movl intel_flag_lookup(,%%%%eax,4),%%%%eax; seto %%%%al; movb %%%%ah,%%1; movl %%%%eax,regflags \""
  712.            ": \"=&r\" (%s), \"=m\" (regs.x) "
  713.            ": \"rmi\" ((WORD)(%s)), \"0\" ((WORD)(%s)) : \"cc\", \"%%eax\");",
  714.            value, src, dst);
  715.         break;
  716.      case sz_long:
  717.         printf("\t__asm__(\"subl %%2,%%0; lahf; movzbl %%%%ah,%%%%eax;"
  718.            " movl intel_flag_lookup(,%%%%eax,4),%%%%eax; seto %%%%al; movb %%%%ah,%%1; movl %%%%eax,regflags \""
  719.            ": \"=&r\" (%s), \"=m\" (regs.x) "
  720.            ": \"rmi\" ((LONG)(%s)), \"0\" ((LONG)(%s)) : \"cc\", \"%%eax\");",
  721.            value, src, dst);
  722.         break;
  723.      case sz_unknown:
  724.         abort();
  725.     }
  726.     return;
  727.  
  728.      case flag_cmp:
  729.     switch (size) {
  730.      case sz_byte:
  731.         printf("\t__asm__(\"movb %%3,%%%%cl; subb %%2,%%%%cl; lahf; movzbl %%%%ah,%%%%eax;"
  732.            " movl intel_flag_lookup(,%%%%eax,4),%%%%eax; seto %%%%al \""
  733.            ": \"=a\" (regflags.longflags), \"=&c\" (%s) "
  734.            ": \"rm\" ((BYTE)(%s)), \"rmi\" ((BYTE)(%s)) : \"cc\");",
  735.            value, src, dst);
  736.         break;
  737.      case sz_word:
  738.         printf("\t__asm__(\"movw %%3,%%%%cx; subw %%2,%%%%cx; lahf; movzbl %%%%ah,%%%%eax;"
  739.            " movl intel_flag_lookup(,%%%%eax,4),%%%%eax; seto %%%%al \""
  740.            ": \"=a\" (regflags.longflags), \"=&c\" (%s) "
  741.            ": \"rm\" ((WORD)(%s)), \"rmi\" ((WORD)(%s)) : \"cc\");",
  742.            value, src, dst);
  743.         break;
  744.      case sz_long:
  745.         printf("\t__asm__(\"movl %%3,%%%%ecx; subl %%2,%%%%ecx; lahf; movzbl %%%%ah,%%%%eax;"
  746.            " movl intel_flag_lookup(,%%%%eax,4),%%%%eax; seto %%%%al \""
  747.            ": \"=a\" (regflags.longflags), \"=&c\" (%s) "
  748.            ": \"rm\" ((LONG)(%s)), \"rmi\" ((LONG)(%s)) : \"cc\");",
  749.            value, src, dst);
  750.         break;
  751.      case sz_unknown:
  752.         abort();
  753.     }
  754.     return;
  755.     }
  756. #endif
  757.     genflags_normal(type, size, value, src, dst);
  758. }
  759. static void gen_opcode(unsigned long int opcode) 
  760. {
  761.     start_brace ();
  762.     switch (table68k[opcode].plev) {
  763.      case 0: /* not priviledged */
  764.     break;
  765.      case 1: /* unpriviledged only on 68000 */
  766.     if (CPU_LEVEL == 0)
  767.         break;
  768.      case 2: /* priviledged */
  769.     printf("if (!regs.s) { regs.pc_p--; Exception(8); } else\n");
  770.     start_brace();
  771.     break;
  772.      case 3: /* priviledged if size == word */
  773.     if (table68k[opcode].size == sz_byte)
  774.         break;
  775.     printf("if (!regs.s) { regs.pc_p--; Exception(8); } else\n");
  776.     start_brace();
  777.     break;
  778.     }
  779.     switch(table68k[opcode].mnemo) {
  780.      case i_OR:
  781.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  782.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  783.     printf("\tsrc |= dst;\n");
  784.     genflags(flag_logical, table68k[opcode].size, "src", "", "");
  785.     genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  786.     break;
  787.      case i_AND:
  788.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  789.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  790.     printf("\tsrc &= dst;\n");
  791.     genflags(flag_logical, table68k[opcode].size, "src", "", "");
  792.     genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  793.     break;
  794.      case i_EOR:
  795.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  796.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  797.     printf("\tsrc ^= dst;\n");
  798.     genflags(flag_logical, table68k[opcode].size, "src", "", "");
  799.     genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  800.     break;
  801.      case i_ORSR:
  802.     printf("\tMakeSR();\n");
  803.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  804.     if (table68k[opcode].size == sz_byte) {
  805.         printf("\tsrc &= 0xFF;\n");
  806.     }
  807.     printf("\tregs.sr |= src;\n");
  808.     printf("\tMakeFromSR();\n");
  809.     break;
  810.      case i_ANDSR:     
  811.     printf("\tMakeSR();\n");
  812.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  813.     if (table68k[opcode].size == sz_byte) {
  814.         printf("\tsrc |= 0xFF00;\n");
  815.     }
  816.     printf("\tregs.sr &= src;\n");
  817.     printf("\tMakeFromSR();\n");
  818.     break;
  819.      case i_EORSR:
  820.     printf("\tMakeSR();\n");
  821.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  822.     if (table68k[opcode].size == sz_byte) {
  823.         printf("\tsrc &= 0xFF;\n");
  824.     }
  825.     printf("\tregs.sr ^= src;\n");
  826.     printf("\tMakeFromSR();\n");
  827.     break;
  828.      case i_SUB: 
  829.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  830.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  831.     start_brace ();
  832.     genflags(flag_sub, table68k[opcode].size, "newv", "src", "dst");
  833.     genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  834.     break;
  835.      case i_SUBA:
  836.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  837.     genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
  838.     start_brace ();
  839.     printf("\tULONG newv = dst - src;\n");
  840.     genastore("newv", table68k[opcode].dmode, "dstreg", sz_long, "dst");
  841.     break;
  842.      case i_SUBX:
  843.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  844.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  845.     start_brace ();
  846.     printf("\tULONG newv = dst - src - (regs.x ? 1 : 0);\n");
  847.     genflags(flag_subx, table68k[opcode].size, "newv", "src", "dst");
  848.     genflags(flag_zn, table68k[opcode].size, "newv", "", "");
  849.     genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  850.     break;
  851.      case i_SBCD:
  852.     /* Let's hope this works... */
  853.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  854.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  855.     start_brace ();
  856.     printf("\tUWORD newv_lo = (dst & 0xF) - (src & 0xF) - regs.x;\n");
  857.     printf("\tUWORD newv_hi = (dst & 0xF0) - (src & 0xF0);\n");
  858.     printf("\tUWORD newv;\n");
  859.     printf("\tif (newv_lo > 9) { newv_lo-=6; newv_hi-=0x10; }\n");
  860.     printf("\tnewv = newv_hi + (newv_lo & 0xF);");
  861.     printf("\tCFLG = regs.x = (newv_hi & 0x1F0) > 0x90;\n");
  862.     printf("\tif (CFLG) newv -= 0x60;\n");
  863.     genflags(flag_zn, table68k[opcode].size, "newv", "", "");    
  864.     genflags(flag_sv, table68k[opcode].size, "newv", "src", "dst");        
  865.     genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  866.     break;
  867.      case i_ADD:
  868.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  869.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  870.     start_brace ();
  871.     genflags(flag_add, table68k[opcode].size, "newv", "src", "dst");
  872.     genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  873.     break;
  874.      case i_ADDA: 
  875.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  876.     genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
  877.     start_brace ();
  878.     printf("\tULONG newv = dst + src;\n");
  879.     genastore("newv", table68k[opcode].dmode, "dstreg", sz_long, "dst");
  880.     break;
  881.      case i_ADDX:
  882.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  883.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  884.     start_brace ();
  885.     printf("\tULONG newv = dst + src + (regs.x ? 1 : 0);\n");
  886.     genflags(flag_addx, table68k[opcode].size, "newv", "src", "dst");
  887.     genflags(flag_zn, table68k[opcode].size, "newv", "", "");
  888.     genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  889.     break;
  890.      case i_ABCD:
  891.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  892.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  893.     start_brace ();
  894.     printf("\tUWORD newv_lo = (src & 0xF) + (dst & 0xF) + regs.x;\n");
  895.     printf("\tUWORD newv_hi = (src & 0xF0) + (dst & 0xF0);\n");
  896.     printf("\tUWORD newv;\n");
  897.     printf("\tif (newv_lo > 9) { newv_lo +=6; }\n");
  898.     printf("\tnewv = newv_hi + newv_lo;");
  899.     printf("\tCFLG = regs.x = (newv & 0x1F0) > 0x90;\n");
  900.     printf("\tif (CFLG) newv += 0x60;\n");
  901.     genflags(flag_zn, table68k[opcode].size, "newv", "", "");
  902.     genflags(flag_sv, table68k[opcode].size, "newv", "src", "dst");    
  903.     genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  904.     break;
  905.      case i_NEG:
  906.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  907.     start_brace ();
  908.     genflags(flag_sub, table68k[opcode].size, "dst", "src", "0");
  909.     genastore("dst",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  910.     break;
  911.      case i_NEGX:
  912.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  913.     start_brace ();
  914.     printf("\tsrc += regs.x;\n");
  915.     genflags(flag_sub, table68k[opcode].size, "dst", "src", "0");
  916.     genastore("dst",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  917.     break;
  918.      case i_NBCD: 
  919.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  920.     start_brace ();
  921.     printf("\tUWORD newv_lo = - (src & 0xF) - regs.x;\n");
  922.     printf("\tUWORD newv_hi = - (src & 0xF0);\n");
  923.     printf("\tUWORD newv;\n");
  924.     printf("\tif (newv_lo > 9) { newv_lo-=6; newv_hi-=0x10; }\n");
  925.     printf("\tnewv = newv_hi + (newv_lo & 0xF);");
  926.     printf("\tCFLG = regs.x = (newv_hi & 0x1F0) > 0x90;\n");
  927.     printf("\tif (CFLG) newv -= 0x60;\n");
  928.     printf("\tif (newv != 0) ZFLG = 0;\n");
  929.     genastore("newv", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  930.     break;
  931.      case i_CLR: 
  932.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  933.     genflags(flag_logical, table68k[opcode].size, "0", "", "");
  934.     genastore("0",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  935.     break;
  936.      case i_NOT: 
  937.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  938.     start_brace ();
  939.     printf("\tULONG dst = ~src;\n");
  940.     genflags(flag_logical, table68k[opcode].size, "dst", "", "");
  941.     genastore("dst",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  942.     break;
  943.      case i_TST:
  944.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  945.     genflags(flag_logical, table68k[opcode].size, "src", "", "");
  946.     break;
  947.      case i_BTST:
  948.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  949.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  950.     if (table68k[opcode].size == sz_byte)
  951.         printf("\tsrc &= 7;\n");
  952.     else
  953.         printf("\tsrc &= 31;\n");
  954.     printf("\tZFLG = !(dst & (1 << src));\n");
  955.     break;
  956.      case i_BCHG:
  957.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  958.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  959.     if (table68k[opcode].size == sz_byte)
  960.         printf("\tsrc &= 7;\n");
  961.     else
  962.         printf("\tsrc &= 31;\n");
  963.     printf("\tZFLG = !(dst & (1 << src));\n");
  964.     printf("\tdst ^= (1 << src);\n");
  965.     genastore("dst", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  966.     break;
  967.      case i_BCLR:
  968.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  969.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  970.     if (table68k[opcode].size == sz_byte)
  971.         printf("\tsrc &= 7;\n");
  972.     else
  973.         printf("\tsrc &= 31;\n");
  974.     printf("\tZFLG = !(dst & (1 << src));\n");
  975.     printf("\tdst &= ~(1 << src);\n");
  976.     genastore("dst", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  977.     break;
  978.      case i_BSET:
  979.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  980.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  981.     if (table68k[opcode].size == sz_byte)
  982.         printf("\tsrc &= 7;\n");
  983.     else
  984.         printf("\tsrc &= 31;\n");
  985.     printf("\tZFLG = !(dst & (1 << src));\n");
  986.     printf("\tdst |= (1 << src);\n");
  987.     genastore("dst", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  988.     break;
  989.      case i_CMPM:
  990.      case i_CMP:
  991.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  992.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  993.     start_brace ();
  994.     genflags(flag_cmp, table68k[opcode].size, "newv", "src", "dst");
  995.     break;
  996.      case i_CMPA: 
  997.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  998.     genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
  999.     start_brace ();
  1000.     genflags(flag_cmp, sz_long, "newv", "src", "dst");
  1001.     break;
  1002.     /* The next two are coded a little unconventional, but they are doing
  1003.      * weird things... */
  1004.      case i_MVPRM:
  1005.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1006.     printf("\tCPTR memp = regs.a[dstreg] + nextiword();\n");
  1007.     if (table68k[opcode].size == sz_word) {
  1008.         printf("\tput_byte(memp, src >> 8); put_byte(memp + 2, src);\n");
  1009.     } else {
  1010.         printf("\tput_byte(memp, src >> 24); put_byte(memp + 2, src >> 16);\n");
  1011.         printf("\tput_byte(memp + 4, src >> 8); put_byte(memp + 6, src);\n");
  1012.     }
  1013.     break;
  1014.      case i_MVPMR: 
  1015.     printf("\tCPTR memp = regs.a[srcreg] + nextiword();\n");
  1016.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 0, 0);
  1017.     if (table68k[opcode].size == sz_word) {
  1018.         printf("\tUWORD val = (get_byte(memp) << 8) + get_byte(memp + 2);\n");
  1019.     } else {
  1020.         printf("\tULONG val = (get_byte(memp) << 24) + (get_byte(memp + 2) << 16)\n");
  1021.         printf("              + (get_byte(memp + 4) << 8) + get_byte(memp + 6);\n");
  1022.     }
  1023.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1024.     break;
  1025.      case i_MOVE:
  1026.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1027.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 0, 0);
  1028.     genflags(flag_logical, table68k[opcode].size, "src", "", "");
  1029.     genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1030.     break;
  1031.      case i_MOVEA:
  1032.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1033.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 0, 0);
  1034.     genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1035.     break;
  1036.      case i_MVSR2: 
  1037.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1038.     printf("\tMakeSR();\n");
  1039.     genastore("regs.sr", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1040.     break;
  1041.      case i_MV2SR:
  1042.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1043.     if (table68k[opcode].size == sz_byte)
  1044.         printf("\tMakeSR();\n\tregs.sr &= 0xFF00;\n\tregs.sr |= src & 0xFF;\n");
  1045.     else {            
  1046.         printf("\tregs.sr = src;\n");
  1047.     }
  1048.     printf("\tMakeFromSR();\n");
  1049.     break;
  1050.      case i_SWAP: 
  1051.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1052.     start_brace ();
  1053.     printf("\tULONG dst = ((src >> 16)&0xFFFF) | ((src&0xFFFF)<<16);\n");
  1054.     genflags(flag_logical, table68k[opcode].size, "dst", "", "");
  1055.     genastore("dst",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1056.     break;
  1057.      case i_EXG:
  1058.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1059.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1060.     genastore("dst",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1061.     genastore("src",table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1062.     break;
  1063.      case i_EXT:
  1064.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1065.     start_brace ();
  1066.     switch(table68k[opcode].size) {
  1067.      case sz_word: printf("\tULONG dst = (LONG)(BYTE)src;\n"); break;
  1068.      case sz_long: printf("\tULONG dst = (LONG)(WORD)src;\n"); break;
  1069.      default: abort();
  1070.     }
  1071.     genflags(flag_logical, table68k[opcode].size, "dst", "", "");
  1072.     genastore("dst",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1073.     break;
  1074.      case i_MVMEL:
  1075.     genmovemel(opcode);
  1076.     break;
  1077.      case i_MVMLE:
  1078.     genmovemle(opcode);
  1079.     break;
  1080.      case i_TRAP:
  1081.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1082.     printf("\tException(src+32);\n");
  1083.     break;
  1084.      case i_MVR2USP:
  1085.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1086.     printf("\tregs.usp = src;\n");
  1087.     break;
  1088.      case i_MVUSP2R: 
  1089.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1090.     genastore("regs.usp", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1091.     break;
  1092.      case i_RESET:
  1093.     printf("\tcustomreset();\n");
  1094.     break;
  1095.      case i_NOP:
  1096.     break;
  1097.      case i_STOP:
  1098.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1099.     printf("\tregs.sr = src;\n");
  1100.     printf("\tMakeFromSR();\n");
  1101.     printf("\tm68k_setstopped(1);\n");
  1102.     break;
  1103.      case i_RTE:
  1104.     genamode(Aipi, "7", sz_word, "sr", 1, 0);
  1105.     genamode(Aipi, "7", sz_long, "pc", 1, 0);
  1106.     if (CPU_LEVEL > 0) {
  1107.         genamode(Aipi, "7", sz_word, "format", 1, 0);
  1108.     }
  1109.     printf("\tregs.sr = sr; m68k_setpc(pc);\n");
  1110.     if (CPU_LEVEL > 0) {
  1111.         printf("\tif ((format & 0xF000) == 0x8000) regs.a[7] += 50;\n");
  1112.     }
  1113.     printf("\tMakeFromSR();\n");
  1114.     break;
  1115.      case i_RTD:
  1116.     break;
  1117.      case i_LINK:
  1118.     genamode(Apdi, "7", sz_long, "old", 0, 0);
  1119.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1120.     genastore("src", Apdi, "7", sz_long, "old");
  1121.     genastore("regs.a[7]", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1122.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "offs", 1, 0);
  1123.     printf("\tregs.a[7] += offs;\n");
  1124.     break;
  1125.      case i_UNLK:
  1126.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1127.     printf("\tregs.a[7] = src;\n");
  1128.     genamode(Aipi, "7", sz_long, "old", 1, 0);
  1129.     genastore("old", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1130.     break;
  1131.      case i_RTS:
  1132.     genamode(Aipi, "7", sz_long, "pc", 1, 0);
  1133.     printf("\tm68k_setpc(pc);\n");
  1134.     break;
  1135.      case i_TRAPV:
  1136.     printf("\tif(VFLG) Exception(7);\n");
  1137.     break;
  1138.      case i_RTR: 
  1139.     printf("\tMakeSR();\n");
  1140.     genamode(Aipi, "7", sz_word, "sr", 1, 0);
  1141.     genamode(Aipi, "7", sz_long, "pc", 1, 0);
  1142.     printf("\tregs.sr &= 0xFF00; sr &= 0xFF;\n");
  1143.     printf("\tregs.sr |= sr; m68k_setpc(pc);\n");
  1144.     printf("\tMakeFromSR();\n");
  1145.     break;
  1146.      case i_JSR:
  1147.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1148.     genamode(Apdi, "7", sz_long, "sp", 0, 0);
  1149.     genastore("m68k_getpc()", Apdi, "7", sz_long, "sp");
  1150.     printf("\tm68k_setpc(srca);\n");
  1151.     break;
  1152.      case i_JMP: 
  1153.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1154.     printf("\tm68k_setpc(srca);\n");
  1155.     break;
  1156.      case i_BSR:
  1157.     printf("\tchar *oldpcp = (char *)regs.pc_p;\n");
  1158.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1159.     genamode(Apdi, "7", sz_long, "sp", 0, 0);
  1160.     genastore("m68k_getpc()", Apdi, "7", sz_long, "sp");
  1161.     printf("\tregs.pc_p = (UWORD *)(oldpcp + (LONG)src);\n");
  1162.     break;
  1163.      case i_Bcc:
  1164.     printf("\tchar *oldpcp = (char *)regs.pc_p;\n");
  1165.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1166.     printf("\tif (cctrue(%d)) regs.pc_p = (UWORD *)(oldpcp + (LONG)src);\n", table68k[opcode].cc);
  1167.     break;
  1168.      case i_LEA:
  1169.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1170.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 0, 0);
  1171.     genastore("srca", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1172.     break;
  1173.      case i_PEA:
  1174.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1175.     genamode(Apdi, "7", sz_long, "dst", 0, 0);
  1176.     genastore("srca", Apdi, "7", sz_long, "dst");
  1177.     break;
  1178.      case i_DBcc:
  1179.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1180.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "offs", 1, 0);
  1181.     printf("\tif (!cctrue(%d)) {\n", table68k[opcode].cc);
  1182.     printf("\tif (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + (LONG)offs - 2);\n");
  1183.     genastore("src", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1184.     printf("\t}\n");
  1185.     break;
  1186.      case i_Scc: 
  1187.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1188.     start_brace ();
  1189.     printf("\tint val = cctrue(%d) ? 0xff : 0;\n", table68k[opcode].cc);
  1190.     genastore("val",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1191.     break;
  1192.      case i_DIVU:
  1193.     genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
  1194.     genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
  1195.     printf("\tif(src != 0){\n");
  1196.     printf("\tULONG newv = (ULONG)dst / (UWORD)src;\n");
  1197.     printf("\tULONG rem = (ULONG)dst %% (UWORD)src;\n");
  1198.     /* The N flag appears to be set each time there is an overflow.
  1199.      * Weird. */
  1200.     printf("\tif (newv > 0xffff) { VFLG = NFLG = 1; } else\n\t{\n");
  1201.     genflags(flag_logical, sz_word, "newv", "", "");
  1202.     printf("\tnewv = (newv & 0xffff) | ((ULONG)rem << 16);\n");
  1203.     genastore("newv",table68k[opcode].dmode, "dstreg", sz_long, "dst");
  1204.     printf("\t}\n");
  1205.     printf("\t}\n");
  1206.     break;
  1207.      case i_DIVS: 
  1208.     genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
  1209.     genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
  1210.     printf("\tif(src != 0){\n");
  1211.     printf("\tLONG newv = (LONG)dst / (WORD)src;\n");
  1212.     printf("\tUWORD rem = (LONG)dst %% (WORD)src;\n");
  1213.     printf("\tif ((newv & 0xffff0000) && (newv & 0xffff0000) != 0xffff0000) { VFLG = NFLG = 1; } else\n\t{\n");
  1214.     printf("\tif (((WORD)rem < 0) != ((LONG)dst < 0)) rem = -rem;\n");
  1215.     genflags(flag_logical, sz_word, "newv", "", "");
  1216.     printf("\tnewv = (newv & 0xffff) | ((ULONG)rem << 16);\n");
  1217.     genastore("newv",table68k[opcode].dmode, "dstreg", sz_long, "dst");
  1218.     printf("\t}\n");
  1219.     printf("\t}\n");
  1220.     break;
  1221.      case i_MULU: 
  1222.     genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
  1223.     genamode(table68k[opcode].dmode, "dstreg", sz_word, "dst", 1, 0);
  1224.     start_brace ();
  1225.     printf("\tULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;\n");
  1226.     genflags(flag_logical, sz_long, "newv", "", "");
  1227.     genastore("newv",table68k[opcode].dmode, "dstreg", sz_long, "dst");
  1228. #ifdef WANT_SLOW_MULTIPLY
  1229.     printf("\tspecialflags |= SPCFLAG_EXTRA_CYCLES;\n");
  1230. #endif
  1231.     break;
  1232.      case i_MULS:
  1233.     genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
  1234.     genamode(table68k[opcode].dmode, "dstreg", sz_word, "dst", 1, 0);
  1235.     start_brace ();
  1236.     printf("\tULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;\n");
  1237.     genflags(flag_logical, sz_long, "newv", "", "");
  1238.     genastore("newv",table68k[opcode].dmode, "dstreg", sz_long, "dst");
  1239. #ifdef WANT_SLOW_MULTIPLY
  1240.     printf("\tspecialflags |= SPCFLAG_EXTRA_CYCLES;\n");
  1241. #endif
  1242.     break;
  1243.      case i_CHK:
  1244.     genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
  1245.     genamode(table68k[opcode].dmode, "dstreg", sz_word, "dst", 1, 0);
  1246.     printf("\tif ((WORD)dst < 0) { NFLG=1; Exception(6); }\n");
  1247.     printf("\telse if ((WORD)dst > (WORD)src) { NFLG=0; Exception(6); }\n");
  1248.     break;
  1249.     
  1250.      case i_ASR: 
  1251.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1252.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1253.     start_brace ();
  1254.     switch(table68k[opcode].size) {
  1255.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1256.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1257.      case sz_long: printf("\tULONG val = data;\n"); break;
  1258.      default: abort();
  1259.     }
  1260.     switch(table68k[opcode].size) {
  1261.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1262.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1263.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1264.      default: abort();
  1265.     }
  1266.     printf("\tULONG sign = cmask & val;\n");
  1267.     printf("\tcnt &= 63;\n");
  1268.     printf("\tVFLG = 0;\n");
  1269.     printf("\tif (!cnt) { CFLG = 0; } else {");
  1270.     printf("\tfor(;cnt;--cnt){\n");
  1271.     printf("\tCFLG=regs.x=val&1; val = ((ULONG)val >> 1) | sign;\n");
  1272.     printf("\t}}\n\tNFLG = sign != 0;\n");
  1273.     printf("\tZFLG = val == 0;\n");
  1274.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1275.     break;
  1276.      case i_ASL:
  1277.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1278.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1279.     start_brace ();
  1280.     switch(table68k[opcode].size) {
  1281.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1282.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1283.      case sz_long: printf("\tULONG val = data;\n"); break;
  1284.      default: abort();
  1285.     }
  1286.     switch(table68k[opcode].size) {
  1287.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1288.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1289.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1290.      default: abort();
  1291.     }
  1292.     printf("\tULONG sign = cmask & val;\n");
  1293.     printf("\tcnt &= 63;\n");
  1294.     printf("\tVFLG = 0;\n");
  1295.     printf("\tif (!cnt) { CFLG = 0; } else { ");
  1296.     printf("\tfor(;cnt;--cnt){\n");
  1297.     printf("\tCFLG=regs.x=(val&cmask)!=0; val <<= 1;\n");
  1298.     printf("\tif ((val&cmask)!=sign)VFLG=1;\n");
  1299.     printf("\t}}\n\tNFLG = (val&cmask) != 0;\n");
  1300.     printf("\tZFLG = val == 0;\n");
  1301.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1302.     break;
  1303.      case i_LSR:
  1304.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1305.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1306.     start_brace ();
  1307.     switch(table68k[opcode].size) {
  1308.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1309.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1310.      case sz_long: printf("\tULONG val = data;\n"); break;
  1311.      default: abort();
  1312.     }
  1313.     switch(table68k[opcode].size) {
  1314.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1315.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1316.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1317.      default: abort();
  1318.     }
  1319.     printf("\tcnt &= 63;\n");
  1320.     printf("\tif (!cnt) { CFLG = 0; } else {");
  1321.     printf("\tint carry = 0;\n");
  1322.     printf("\tfor(;cnt;--cnt){\n");
  1323.     printf("\tcarry=val&1; val >>= 1;\n");
  1324.     printf("\t}\n");
  1325.     printf("\tCFLG = regs.x = carry!=0;\n}\n");
  1326.     printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
  1327.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");    
  1328.     break;
  1329.      case i_LSL:
  1330.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1331.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1332.     start_brace ();
  1333.     switch(table68k[opcode].size) {
  1334.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1335.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1336.      case sz_long: printf("\tULONG val = data;\n"); break;
  1337.      default: abort();
  1338.     }
  1339.     switch(table68k[opcode].size) {
  1340.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1341.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1342.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1343.      default: abort();
  1344.     }
  1345.     printf("\tint carry = 0;\n");
  1346.     printf("\tcnt &= 63;\n");
  1347.     printf("\tif (!cnt) { CFLG = 0; } else {");
  1348.     printf("\tfor(;cnt;--cnt){\n");
  1349.     printf("\tcarry=val&cmask; val <<= 1;\n");
  1350.     printf("\t}\n");
  1351.     printf("\tCFLG = regs.x = carry!=0;\n}\n");
  1352.     printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
  1353.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1354.     break;
  1355.      case i_ROL:
  1356.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1357.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1358.     start_brace ();
  1359.     switch(table68k[opcode].size) {
  1360.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1361.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1362.      case sz_long: printf("\tULONG val = data;\n"); break;
  1363.      default: abort();
  1364.     }
  1365.     switch(table68k[opcode].size) {
  1366.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1367.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1368.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1369.      default: abort();
  1370.     }
  1371.     printf("\tint carry = 0;\n");
  1372.     printf("\tcnt &= 63;\n");    
  1373.     printf("\tif (!cnt) { CFLG = 0; } else {");
  1374.     printf("\tfor(;cnt;--cnt){\n");
  1375.     printf("\tcarry=val&cmask; val <<= 1;\n");
  1376.     printf("\tif(carry)  val |= 1;\n");
  1377.     printf("\t}\n");
  1378.     printf("\tCFLG = carry!=0;\n}\n");
  1379.     printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
  1380.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1381.     break;
  1382.      case i_ROR:
  1383.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1384.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1385.     start_brace ();
  1386.     switch(table68k[opcode].size) {
  1387.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1388.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1389.      case sz_long: printf("\tULONG val = data;\n"); break;
  1390.      default: abort();
  1391.     }
  1392.     switch(table68k[opcode].size) {
  1393.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1394.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1395.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1396.      default: abort();
  1397.     }
  1398.     printf("\tint carry = 0;\n");    
  1399.     printf("\tcnt &= 63;\n");
  1400.     printf("\tif (!cnt) { CFLG = 0; } else {");
  1401.     printf("\tfor(;cnt;--cnt){\n");
  1402.     printf("\tcarry=val&1; val = (ULONG)val >> 1;\n");
  1403.     printf("\tif(carry) val |= cmask;\n");
  1404.     printf("\t}\n");
  1405.     printf("\tCFLG = carry!=0;\n}\n");
  1406.     printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
  1407.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1408.     break;
  1409.      case i_ROXL: 
  1410.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1411.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1412.     start_brace ();
  1413.     switch(table68k[opcode].size) {
  1414.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1415.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1416.      case sz_long: printf("\tULONG val = data;\n"); break;
  1417.      default: abort();
  1418.     }
  1419.     switch(table68k[opcode].size) {
  1420.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1421.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1422.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1423.      default: abort();
  1424.     }
  1425.     printf("\tint carry = 0;\n");
  1426.     printf("\tcnt &= 63;\n");
  1427.     printf("\tfor(;cnt;--cnt){\n");
  1428.     printf("\tcarry=val&cmask; val <<= 1;\n");
  1429.     printf("\tif(regs.x) val |= 1;\n");    
  1430.     printf("\tregs.x = carry != 0;\n");
  1431.     printf("\t}\n");
  1432.     printf("\tCFLG = regs.x;\n");
  1433.     printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
  1434.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1435.     break;
  1436.      case i_ROXR:
  1437.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1438.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1439.     start_brace ();
  1440.     switch(table68k[opcode].size) {
  1441.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1442.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1443.      case sz_long: printf("\tULONG val = data;\n"); break;
  1444.      default: abort();
  1445.     }
  1446.     switch(table68k[opcode].size) {
  1447.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1448.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1449.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1450.      default: abort();
  1451.     }
  1452.     printf("\tint carry = 0;\n");
  1453.     printf("\tcnt &= 63;\n");
  1454.     printf("\tfor(;cnt;--cnt){\n");
  1455.     printf("\tcarry=val&1; val >>= 1;\n");
  1456.     printf("\tif(regs.x) val |= cmask;\n");
  1457.     printf("\tregs.x = carry != 0;\n");
  1458.     printf("\t}\n");
  1459.     printf("\tCFLG = regs.x;\n");
  1460.     printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
  1461.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1462.     break;
  1463.      case i_ASRW:
  1464.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1465.     printf("\tVFLG = 0;\n");
  1466.     start_brace ();
  1467.     switch(table68k[opcode].size) {
  1468.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1469.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1470.      case sz_long: printf("\tULONG val = data;\n"); break;
  1471.      default: abort();
  1472.     }
  1473.     switch(table68k[opcode].size) {
  1474.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1475.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1476.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1477.      default: abort();
  1478.     }
  1479.     printf("\tULONG sign = cmask & val;\n");
  1480.     printf("\tCFLG=regs.x=val&1; val = (val >> 1) | sign;\n");
  1481.     printf("\tNFLG = sign != 0;\n");
  1482.     printf("\tZFLG = val == 0;\n");
  1483.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1484.     break;
  1485.      case i_ASLW:
  1486.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1487.     printf("\tVFLG = 0;\n");
  1488.     start_brace ();
  1489.     switch(table68k[opcode].size) {
  1490.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1491.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1492.      case sz_long: printf("\tULONG val = data;\n"); break;
  1493.      default: abort();
  1494.     }
  1495.     switch(table68k[opcode].size) {
  1496.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1497.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1498.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1499.      default: abort();
  1500.     }
  1501.     printf("\tULONG sign = cmask & val;\n");
  1502.     printf("\tCFLG=regs.x=(val&cmask)!=0; val <<= 1;\n");
  1503.     printf("\tif ((val&cmask)!=sign) VFLG=1;\n");
  1504.     printf("\tNFLG = (val&cmask) != 0;\n");
  1505.     printf("\tZFLG = val == 0;\n");
  1506.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1507.     break;
  1508.      case i_LSRW:
  1509.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1510.     start_brace ();
  1511.     switch(table68k[opcode].size) {
  1512.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1513.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1514.      case sz_long: printf("\tULONG val = data;\n"); break;
  1515.      default: abort();
  1516.     }
  1517.     printf("\tint carry = val&1;\n");
  1518.     printf("\tcarry=val&1; val >>= 1;\n");
  1519.     genflags(flag_logical, table68k[opcode].size, "val", "", "");
  1520.     printf("CFLG = regs.x = carry!=0;\n");
  1521.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1522.     break;
  1523.      case i_LSLW:
  1524.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1525.     start_brace ();
  1526.     switch(table68k[opcode].size) {
  1527.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1528.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1529.      case sz_long: printf("\tULONG val = data;\n"); break;
  1530.      default: abort();
  1531.     }
  1532.     switch(table68k[opcode].size) {
  1533.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1534.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1535.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1536.      default: abort();
  1537.     }
  1538.     printf("\tint carry = val&cmask;\n");
  1539.     printf("\tval <<= 1;\n");
  1540.     genflags(flag_logical, table68k[opcode].size, "val", "", "");
  1541.     printf("CFLG = regs.x = carry!=0;\n");
  1542.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1543.     break;
  1544.      case i_ROLW:
  1545.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1546.     start_brace ();
  1547.     switch(table68k[opcode].size) {
  1548.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1549.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1550.      case sz_long: printf("\tULONG val = data;\n"); break;
  1551.      default: abort();
  1552.     }
  1553.     switch(table68k[opcode].size) {
  1554.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1555.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1556.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1557.      default: abort();
  1558.     }
  1559.     printf("\tint carry = val&cmask;\n");
  1560.     printf("\tval <<= 1;\n");
  1561.     printf("\tif(carry)  val |= 1;\n");
  1562.     genflags(flag_logical, table68k[opcode].size, "val", "", "");
  1563.     printf("CFLG = carry!=0;\n");
  1564.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1565.     break;
  1566.      case i_RORW:
  1567.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1568.     start_brace ();
  1569.     switch(table68k[opcode].size) {
  1570.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1571.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1572.      case sz_long: printf("\tULONG val = data;\n"); break;
  1573.      default: abort();
  1574.     }
  1575.     printf("\tint carry = val&1;\n");
  1576.     switch(table68k[opcode].size) {
  1577.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1578.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1579.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1580.      default: abort();
  1581.     }
  1582.     printf("\tval >>= 1;\n");
  1583.     printf("\tif(carry) val |= cmask;\n");
  1584.     genflags(flag_logical, table68k[opcode].size, "val", "", "");
  1585.     printf("CFLG = carry!=0;\n");
  1586.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1587.     break;
  1588.      case i_ROXLW:
  1589.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1590.     start_brace ();
  1591.     switch(table68k[opcode].size) {
  1592.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1593.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1594.      case sz_long: printf("\tULONG val = data;\n"); break;
  1595.      default: abort();
  1596.     }
  1597.     switch(table68k[opcode].size) {
  1598.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1599.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1600.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1601.      default: abort();
  1602.     }
  1603.     printf("\tint carry = val&cmask;\n");
  1604.     printf("\tval <<= 1;\n");
  1605.     printf("\tif(regs.x) val |= 1;\n");
  1606.     printf("\tregs.x = carry != 0;\n");
  1607.     genflags(flag_logical, table68k[opcode].size, "val", "", "");
  1608.     printf("regs.x = CFLG = carry!=0;\n");
  1609.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1610.     break;
  1611.      case i_ROXRW:
  1612.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1613.     start_brace ();
  1614.     switch(table68k[opcode].size) {
  1615.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1616.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1617.      case sz_long: printf("\tULONG val = data;\n"); break;
  1618.      default: abort();
  1619.     }
  1620.     printf("\tint carry = val&1;\n");
  1621.     switch(table68k[opcode].size) {
  1622.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1623.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1624.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1625.      default: abort();
  1626.     }
  1627.     printf("\tval >>= 1;\n");
  1628.     printf("\tif(regs.x) val |= cmask;\n");
  1629.     printf("\tregs.x = carry != 0;\n");
  1630.     genflags(flag_logical, table68k[opcode].size, "val", "", "");
  1631.     printf("regs.x = CFLG = carry!=0;\n");
  1632.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1633.     break;
  1634.      case i_MOVEC2:
  1635.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1636.     start_brace();
  1637.     printf("\tint regno = (src >> 12) & 7;\n");
  1638.     printf("\tULONG *regp = src & 0x8000 ? regs.a + regno : regs.d + regno;\n");
  1639.     printf("\tm68k_movec2(src & 0xFFF, regp);\n");
  1640.     break;
  1641.      case i_MOVE2C:
  1642.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1643.     start_brace();
  1644.     printf("\tint regno = (src >> 12) & 7;\n");
  1645.     printf("\tULONG *regp = src & 0x8000 ? regs.a + regno : regs.d + regno;\n");
  1646.     printf("\tm68k_move2c(src & 0xFFF, regp);\n");
  1647.     break;
  1648.      case i_CAS:
  1649.     {
  1650.         int old_brace_level;
  1651.         genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1652.         genamode (table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1653.         start_brace();
  1654.         printf("\tint ru = (src >> 6) & 7;\n");
  1655.         printf("\tint rc = src & 7;\n");
  1656.         printf("\tif ((LONG)regs.d[rc] == (LONG)dst)");
  1657.         old_brace_level = n_braces;
  1658.         start_brace ();
  1659.         genastore("(regs.d[ru])",table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1660.         pop_braces (old_brace_level);
  1661.         printf("else");
  1662.         start_brace ();
  1663.         printf("regs.d[rc] = dst;\n");
  1664.         pop_braces (old_brace_level);
  1665.     }
  1666.     break;
  1667.      case i_DIVL:
  1668.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
  1669.     genamode (table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1670.     printf("\tm68k_divl(opcode, dst, extra);\n");
  1671.     break;
  1672.      case i_MULL:
  1673.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
  1674.     genamode (table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1675.     printf("\tm68k_mull(opcode, dst, extra);\n");
  1676.     break;
  1677.      default:
  1678.     abort();
  1679.     break;
  1680.     };
  1681.     finish_braces ();
  1682. }
  1683.  
  1684. static void generate_func(long int from, long int to)
  1685. {
  1686.     int illg = 0;
  1687.     long int opcode;
  1688.     UWORD smsk; 
  1689.     UWORD dmsk;    
  1690.  
  1691.     printf("#include \"sysconfig.h\"\n");
  1692.     printf("#include \"sysdeps.h\"\n");
  1693.     printf("#include \"config.h\"\n");
  1694.     printf("#include \"options.h\"\n");
  1695.     printf("#include \"memory.h\"\n");
  1696.     printf("#include \"custom.h\"\n");    
  1697.     printf("#include \"newcpu.h\"\n");
  1698.     printf("#include \"cputbl.h\"\n");
  1699.     for(opcode=from; opcode < to; opcode++) {
  1700.     if (table68k[opcode].mnemo == i_ILLG) {
  1701.         illg++;
  1702.         continue;
  1703.     }
  1704.  
  1705.     if (isspecific(opcode)) {
  1706.         printf("void op_%lx_s(ULONG opcode)\n{\n", opcode);
  1707.         if (table68k[opcode].suse
  1708.         && table68k[opcode].smode != imm  && table68k[opcode].smode != imm0
  1709.         && table68k[opcode].smode != imm1 && table68k[opcode].smode != imm2
  1710.         && table68k[opcode].smode != absw && table68k[opcode].smode != absl
  1711.         && table68k[opcode].smode != PC8r && table68k[opcode].smode != PC16)
  1712.         {
  1713.         printf("\tULONG srcreg = (LONG)(BYTE)%d;\n", (int)table68k[opcode].sreg);
  1714.         }
  1715.         if (table68k[opcode].duse
  1716.         /* Yes, the dmode can be imm, in case of LINK or DBcc */
  1717.         && table68k[opcode].dmode != imm  && table68k[opcode].dmode != imm0
  1718.         && table68k[opcode].dmode != imm1 && table68k[opcode].dmode != imm2
  1719.         && table68k[opcode].dmode != absw && table68k[opcode].dmode != absl) {
  1720.         printf("\tULONG dstreg = (LONG)(BYTE)%d;\n", (int)table68k[opcode].dreg);
  1721.         }
  1722.         gen_opcode(opcode);
  1723.         printf("}\n");
  1724.     }
  1725.         
  1726.     if (table68k[opcode].handler != -1)
  1727.         continue;
  1728.  
  1729.  
  1730.     switch (table68k[opcode].stype) {
  1731.      case 0:
  1732.         smsk = 7; break;
  1733.      case 1:
  1734.         smsk = 255; break;
  1735.      case 2:
  1736.         smsk = 15; break;
  1737.      case 3:
  1738.         smsk = 7; break;
  1739.      default:
  1740.         abort();
  1741.     }
  1742.     smsk <<= table68k[opcode].spos;
  1743.     dmsk = 7 << table68k[opcode].dpos;
  1744.     
  1745.     printf("void op_%lx(ULONG opcode)\n{\n", opcode);
  1746.     if (table68k[opcode].suse
  1747.         && table68k[opcode].smode != imm  && table68k[opcode].smode != imm0
  1748.         && table68k[opcode].smode != imm1 && table68k[opcode].smode != imm2
  1749.         && table68k[opcode].smode != absw && table68k[opcode].smode != absl
  1750.         && table68k[opcode].smode != PC8r && table68k[opcode].smode != PC16)
  1751.     {
  1752.         if (table68k[opcode].spos == -1) {
  1753.         printf("\tULONG srcreg = (LONG)(BYTE)%d;\n", (int)table68k[opcode].sreg);
  1754.         } else {
  1755.         if (table68k[opcode].stype == 3)
  1756.             printf("\tULONG srcreg = imm8_table[(opcode & %d) >> %d];\n",
  1757.                smsk, (int)table68k[opcode].spos);
  1758.         else
  1759.             printf("\tULONG srcreg = (LONG)(BYTE)((opcode & %d) >> %d);\n", 
  1760.                smsk, (int)table68k[opcode].spos);
  1761.         }
  1762.     }
  1763.     if (table68k[opcode].duse
  1764.         /* Yes, the dmode can be imm, in case of LINK or DBcc */
  1765.         && table68k[opcode].dmode != imm  && table68k[opcode].dmode != imm0
  1766.         && table68k[opcode].dmode != imm1 && table68k[opcode].dmode != imm2
  1767.         && table68k[opcode].dmode != absw && table68k[opcode].dmode != absl) {
  1768.         if (table68k[opcode].dpos == -1) {        
  1769.         printf("\tULONG dstreg = (LONG)(BYTE)%d;\n", (int)table68k[opcode].dreg);
  1770.         } else {
  1771.         printf("\tULONG dstreg = (opcode & %d) >> %d;\n", dmsk, (int)table68k[opcode].dpos);
  1772.         }
  1773.     }
  1774.     gen_opcode(opcode);
  1775.         printf("}\n");
  1776.     }
  1777.  
  1778.     fprintf (stderr, "%d illegals generated.\n", illg);
  1779. }
  1780.  
  1781. static void generate_table(void)
  1782. {
  1783.     int illg = 0;
  1784.     long int opcode;
  1785.     
  1786.     printf("#include \"sysconfig.h\"\n");
  1787.     printf("#include \"sysdeps.h\"\n");
  1788.     printf("#include \"config.h\"\n");
  1789.     printf("#include \"options.h\"\n");
  1790.     printf("#include \"memory.h\"\n");
  1791.     printf("#include \"custom.h\"\n");
  1792.     printf("#include \"newcpu.h\"\n");
  1793.     printf("#include \"cputbl.h\"\n");
  1794.     
  1795.     printf("cpuop_func *cpufunctbl[65536] = {\n");
  1796.     for(opcode=0; opcode < 65536; opcode++) {
  1797.     if (table68k[opcode].mnemo == i_ILLG) {
  1798.         printf("op_illg");
  1799.         illg++;
  1800.     } else if (isspecific(opcode))
  1801.         printf("op_%lx_s", opcode);
  1802.     else if (table68k[opcode].handler != -1)
  1803.         printf("op_%lx", table68k[opcode].handler);
  1804.     else
  1805.         printf("op_%lx", opcode);
  1806.     
  1807.     if (opcode < 65535) printf(",");
  1808.     if ((opcode & 7) == 7) printf("\n");
  1809.     }
  1810.     printf("\n};\n");
  1811.     fprintf (stderr, "%d illegals generated.\n", illg);
  1812.     if (get_no_mismatches())
  1813.     fprintf(stderr, "%d mismatches.\n", get_no_mismatches());
  1814. }
  1815.  
  1816. static void generate_smalltable(void)
  1817. {
  1818.     long int opcode;
  1819.     
  1820.     printf("#include \"sysconfig.h\"\n");
  1821.     printf("#include \"sysdeps.h\"\n");
  1822.     printf("#include \"config.h\"\n");
  1823.     printf("#include \"options.h\"\n");
  1824.     printf("#include \"memory.h\"\n");
  1825.     printf("#include \"custom.h\"\n");
  1826.     printf("#include \"newcpu.h\"\n");
  1827.     printf("#include \"cputbl.h\"\n");
  1828.     
  1829.     printf("struct cputbl smallcputbl[] = {\n");
  1830.     for(opcode=0; opcode < 65536; opcode++) {
  1831.     if ((isspecific(opcode) || table68k[opcode].handler == -1)
  1832.         && table68k[opcode].mnemo != i_ILLG) 
  1833.     {
  1834.         if (isspecific(opcode))
  1835.         printf("{ op_%x_s, 1, %d },\n", opcode, opcode);
  1836.         if (table68k[opcode].handler == -1)
  1837.         printf("{ op_%x, 0, %d },\n", opcode, opcode);
  1838.     }
  1839.     }
  1840.     printf("{ 0, 0, 0 }};\n");
  1841. }
  1842.  
  1843. static void generate_header(void)
  1844. {
  1845.     int illg = 0;
  1846.     long int opcode;
  1847.     
  1848.     for(opcode=0; opcode < 65536; opcode++) {
  1849.     if (table68k[opcode].mnemo == i_ILLG) {
  1850.         illg++;
  1851.         continue;
  1852.     }
  1853.     if (isspecific(opcode))
  1854.         printf("extern cpuop_func op_%lx_s;\n", opcode);
  1855.     if (table68k[opcode].handler != -1)
  1856.         continue;
  1857.     
  1858.     printf("extern cpuop_func op_%lx;\n", opcode);
  1859.     }
  1860.     
  1861.     fprintf (stderr, "%d illegals generated.\n", illg);
  1862.     if (get_no_mismatches())
  1863.     fprintf(stderr, "%d mismatches.\n", get_no_mismatches());
  1864. }
  1865.  
  1866. int main(int argc, char **argv)
  1867. {
  1868.     long int range = -1;
  1869.     char mode = 'n';
  1870.     int i;
  1871.     
  1872.     if (argc == 2)
  1873.         mode = *argv[1];
  1874.  
  1875.     if (argc == 3) {
  1876.     range = atoi(argv[2]);
  1877.     mode = *argv[1];
  1878.     }
  1879.     
  1880.     read_table68k ();
  1881.     read_counts();
  1882.     do_merges ();
  1883.     
  1884.     switch(mode) {
  1885.      case 'f':
  1886.         generate_func(range * 0x1000, (range + 1) * 0x1000);
  1887.     break;
  1888.      case 'h':
  1889.         generate_header();
  1890.     break;
  1891.      case 't':
  1892.     generate_table();
  1893.     break;
  1894.      case 's':
  1895.     generate_smalltable();
  1896.     break;
  1897.      default:
  1898.     abort();
  1899.     }
  1900.     free(table68k);
  1901.     return 0;
  1902. }
  1903.